package com.xxc.smartcar.wifi;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.RadioGroup;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;

import com.google.android.material.button.MaterialButton;
import com.google.android.material.radiobutton.MaterialRadioButton;
import com.google.android.material.switchmaterial.SwitchMaterial;
import com.xxc.smartcar.R;
import com.xxc.smartcar.utils.HttpUtils;
import com.xxc.smartcar.wifi.bean.DeviceInfo;

import org.json.JSONException;
import org.json.JSONObject;

import java.util.Timer;
import java.util.TimerTask;

public class WifiCarActivity extends AppCompatActivity {
    private static final String TAG = "WifiCarActivity";
    private static final int MSG_AUTO_STOP = 1001;
    private static final long SHORT_PRESS_DELAY = 500; // 短按自动停止延迟
    private static final long LONG_PRESS_THRESHOLD = 3000; // 长按阈值

    // 云平台返回状态码常量
    private static final int CODE_SUCCESS = 0; // 成功
    private static final int CODE_DEVICE_OFFLINE = 10411; // 设备不在线

    // UI控件
    private TextView tvCurrentState;
    private TextView tvConnectionStatus;
    private TextView tvBattery;
    private TextView tvTemp;
    private TextView tvHum;
    private TextView tvSpeedValue;

    private MaterialButton btnUp, btnDown, btnLeft, btnRight, btnStop, btnMode;
    private SwitchMaterial switchLed;
    private RadioGroup ledModeGroup;
    private SeekBar speedSeekbar;

    // 数据变量
    private DeviceInfo deviceInfo;
    private boolean isAutoMode = false; // 是否自动模式
    private boolean isLedEnabled = false; // LED是否启用
    private Timer dataUpdateTimer; // 数据更新定时器
    private Handler mainHandler; // 主线程Handler
    private Handler autoStopHandler; // 自动停止处理器
    private BatteryReceiver batteryReceiver; // 电池状态广播接收器

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_car);

        // 初始化主线程Handler
        mainHandler = new Handler(Looper.getMainLooper());

        // 初始化自动停止Handler
        autoStopHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                if (msg.what == MSG_AUTO_STOP) {
                    // 执行自动停止
                    String direction = (String) msg.obj;
                    stopCarIfNeeded(direction);
                }
            }
        };

        // 初始化设备信息
        deviceInfo = new DeviceInfo();

        // 初始化UI控件
        initViews();

        // 初始化事件监听
        initListeners();

        // 注册电池广播接收器
        registerBatteryReceiver();

        // 启动数据更新定时器
        startDataUpdateTimer();
    }

    /**
     * 初始化UI控件
     */
    private void initViews() {
        // 标题栏
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        if (getSupportActionBar() != null) {
            getSupportActionBar().setDisplayShowTitleEnabled(false);
        }

        // 状态显示控件
        tvCurrentState = findViewById(R.id.current_state);
        tvConnectionStatus = findViewById(R.id.connection_status);
        tvBattery = findViewById(R.id.battery_level);
        tvTemp = findViewById(R.id.tv_temp);
        tvHum = findViewById(R.id.tv_hum);
        tvSpeedValue = findViewById(R.id.speed_value);

        // 控制按钮
        btnMode = findViewById(R.id.btn_mode);
        switchLed = findViewById(R.id.switch_led);
        ledModeGroup = findViewById(R.id.led_mode_group);
        speedSeekbar = findViewById(R.id.speed_seekbar);

        // 方向控制按钮
        btnUp = findViewById(R.id.btn_up);
        btnDown = findViewById(R.id.btn_down);
        btnLeft = findViewById(R.id.btn_left);
        btnRight = findViewById(R.id.btn_right);
        btnStop = findViewById(R.id.btn_stop);

        // 默认选中LED熄灭模式
        ((MaterialRadioButton) ledModeGroup.getChildAt(0)).setChecked(true);

        // 初始获取一次电池电量
        updateBatteryLevel();
    }

    /**
     * 初始化事件监听器
     */
    private void initListeners() {
        // 模式切换按钮（自动/手动）
        btnMode.setOnClickListener(v -> {
            isAutoMode = !isAutoMode;
            if (isAutoMode) {
                btnMode.setText("自动模式");
                deviceInfo.setModel("auto");
                tvCurrentState.setText("自动模式");
            } else {
                btnMode.setText("手动模式");
                deviceInfo.setModel("manual");
                tvCurrentState.setText("停止");
                deviceInfo.setCarDirection("stop");
            }
            sendControlCommand();
        });

        // LED开关控制
        switchLed.setOnCheckedChangeListener((buttonView, isChecked) -> {
            isLedEnabled = isChecked;
            if (!isLedEnabled) {
                // 关闭LED
                deviceInfo.setLed("ledOff");
                ((MaterialRadioButton) ledModeGroup.getChildAt(0)).setChecked(true);
            } else {
                // 开启LED，默认选择跑马灯模式
                deviceInfo.setLed("led1");
                ((MaterialRadioButton) ledModeGroup.getChildAt(1)).setChecked(true);
            }
            sendControlCommand();
        });

        // LED模式选择
        ledModeGroup.setOnCheckedChangeListener((group, checkedId) -> {
            int checkedPosition = -1;
            for (int i = 0; i < group.getChildCount(); i++) {
                MaterialRadioButton rb = (MaterialRadioButton) group.getChildAt(i);
                if (rb.getId() == checkedId) {
                    checkedPosition = i;
                    break;
                }
            }

            // 根据选择的位置设置LED模式
            switch (checkedPosition) {
                case 0: // 熄灭
                    deviceInfo.setLed("ledOff");
                    switchLed.setChecked(false);
                    break;
                case 1: // 跑马灯
                    deviceInfo.setLed("led1");
                    switchLed.setChecked(true);
                    break;
                case 2: // 流水灯
                    deviceInfo.setLed("led2");
                    switchLed.setChecked(true);
                    break;
                case 3: // 闪烁灯
                    deviceInfo.setLed("led3");
                    switchLed.setChecked(true);
                    break;
                case 4: // 呼吸灯
                    deviceInfo.setLed("led4");
                    switchLed.setChecked(true);
                    break;
                case 5: // 彩虹循环
                    deviceInfo.setLed("led5");
                    switchLed.setChecked(true);
                    break;
                case 6: // 自定义模式
                    deviceInfo.setLed("led6");
                    switchLed.setChecked(true);
                    break;
            }
            sendControlCommand();
        });

        speedSeekbar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
                if (b) {
                    int speed = i;
                    tvSpeedValue.setText(speed + "%");
                    deviceInfo.setSpeed(speed);
                    sendControlCommand();
                }
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {

            }
        });

        // 方向控制按钮 - 触摸事件（区分短按和长按）
        btnUp.setOnTouchListener(new DirectionButtonTouchListener("run", "前进"));
        btnDown.setOnTouchListener(new DirectionButtonTouchListener("back", "后退"));
        btnLeft.setOnTouchListener(new DirectionButtonTouchListener("left", "左转"));
        btnRight.setOnTouchListener(new DirectionButtonTouchListener("right", "右转"));

        // 停止按钮
        btnStop.setOnClickListener(v -> {
            deviceInfo.setCarDirection("stop");
            tvCurrentState.setText("停止");
            sendControlCommand();
        });
    }

    /**
     * 方向按钮触摸监听器 - 实现短按自动停止和长按提示并保持状态
     */
    private class DirectionButtonTouchListener implements View.OnTouchListener {
        private String direction;
        private String stateText;
        private long pressStartTime; // 按下开始时间
        private boolean isLongPress; // 是否为长按
        private boolean isAutoStopScheduled; // 是否已安排自动停止
        private boolean isLongPressNotified; // 是否已发送长按提示
        private Runnable longPressRunnable; // 长按检测Runnable

        public DirectionButtonTouchListener(String direction, String stateText) {
            this.direction = direction;
            this.stateText = stateText;
            this.isLongPress = false;
            this.isAutoStopScheduled = false;
            this.isLongPressNotified = false;

            // 初始化长按Runnable
            initLongPressRunnable();
        }

        /**
         * 初始化长按检测Runnable
         */
        private void initLongPressRunnable() {
            longPressRunnable = new Runnable() {
                @Override
                public void run() {
                    isLongPress = true;
                    // 取消已安排的自动停止
                    cancelAutoStop();

                    // 显示长按提示
                    if (!isLongPressNotified) {
                        mainHandler.post(() ->
                                Toast.makeText(WifiCarActivity.this,
                                        "已进入持续" + stateText + "模式",
                                        Toast.LENGTH_SHORT).show()
                        );
                        isLongPressNotified = true;
                    }

                    // 持续发送当前方向指令，确保小车保持状态
                    sendControlCommand();

                    // 继续注册自身，实现长按期间持续保持状态
                    mainHandler.postDelayed(this, 1000); // 每1秒发送一次状态保持指令
                }
            };
        }

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            if (!isAutoMode) { // 只有手动模式下方向控制有效
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        // 记录按下时间，初始化状态
                        pressStartTime = System.currentTimeMillis();
                        isLongPress = false;
                        isAutoStopScheduled = false;
                        isLongPressNotified = false;

                        // 发送方向指令
                        deviceInfo.setCarDirection(direction);
                        tvCurrentState.setText(stateText);
                        sendControlCommand();

                        // 启动长按检测
                        mainHandler.postDelayed(longPressRunnable, LONG_PRESS_THRESHOLD);
                        break;

                    case MotionEvent.ACTION_UP:
                    case MotionEvent.ACTION_CANCEL:
                        // 移除长按检测
                        mainHandler.removeCallbacks(longPressRunnable);

                        if (!isLongPress) {
                            // 短按情况：取消可能的自动停止任务，重新安排
                            cancelAutoStop();

                            // 如果按下时间小于长按阈值，安排自动停止
                            long pressDuration = System.currentTimeMillis() - pressStartTime;
                            if (pressDuration < LONG_PRESS_THRESHOLD) {
                                scheduleAutoStop(direction);
                            }
                        }
                        // 长按情况下不做任何处理，保持当前状态
                        break;
                }
            } else {
                Toast.makeText(WifiCarActivity.this, "自动模式下无法手动控制方向", Toast.LENGTH_SHORT).show();
            }
            return true; // 确保所有触摸事件都被处理
        }

        // 安排自动停止
        private void scheduleAutoStop(String dir) {
            Message msg = autoStopHandler.obtainMessage(MSG_AUTO_STOP, dir);
            autoStopHandler.sendMessageDelayed(msg, SHORT_PRESS_DELAY);
            isAutoStopScheduled = true;
        }

        // 取消自动停止
        private void cancelAutoStop() {
            if (isAutoStopScheduled) {
                autoStopHandler.removeMessages(MSG_AUTO_STOP);
                isAutoStopScheduled = false;
            }
        }
    }

    /**
     * 必要时停止小车
     */
    private void stopCarIfNeeded(String direction) {
        // 只有当前方向与要停止的方向一致时才发送停止指令
        if (direction.equals(deviceInfo.getCarDirection())) {
            deviceInfo.setCarDirection("stop");
            tvCurrentState.setText("停止");
            sendControlCommand();
        }
    }

    /**
     * 发送控制指令到云平台
     */
    private void sendControlCommand() {
        new Thread(() -> HttpUtils.sendPost(deviceInfo)).start();
    }

    /**
     * 启动数据更新定时器，定期获取温湿度等信息
     */
    private void startDataUpdateTimer() {
        dataUpdateTimer = new Timer();
        dataUpdateTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                // 获取设备数据（HttpUtils.sendGet()需返回云平台外层JSON对象）
                JSONObject cloudResponse = HttpUtils.sendGet();
                // 在主线程更新UI
                mainHandler.post(() -> updateDeviceDataUI(cloudResponse));
            }
        }, 0, 5000); // 立即执行，每5秒更新一次
    }

    /**
     * 更新设备数据UI显示（核心修改：解析云平台嵌套JSON并处理状态码）
     * @param cloudResponse 云平台返回的外层JSON对象
     */
    private void updateDeviceDataUI(JSONObject cloudResponse) {
        // 1. 先处理外层JSON为空的情况
        if (cloudResponse == null) {
            tvConnectionStatus.setText("连接失败（无响应）");
            tvConnectionStatus.setTextColor(getResources().getColor(R.color.error_color));
            return;
        }

        try {
            // 2. 获取JSON的核心字段：data（嵌套的业务JSON字符串）
            String dataStr = cloudResponse.optString("data", "-1");;
            JSONObject businessData = new JSONObject(dataStr); // 解析数据层JSON

            // 3. 根据业务层状态码处理不同逻辑
            int businessCode = cloudResponse.optInt("code", -1);
            switch (businessCode) {
                case CODE_SUCCESS:
                    // 3.1 成功状态：解析设备数据并更新UI
                    handleSuccessData(businessData);
                    break;

                case CODE_DEVICE_OFFLINE:
                    // 3.2 设备不在线：更新连接状态
                    tvConnectionStatus.setText("设备不在线");
                    tvConnectionStatus.setTextColor(getResources().getColor(R.color.error_color));
                    // 清空温湿度显示（设备离线时数据无效）
                    tvTemp.setText("--°C");
                    tvHum.setText("--%");
                    break;

                default:
                    // 3.3 其他错误状态：显示错误信息
                    String errorMsg = businessData.optString("msg", "未知错误");
                    tvConnectionStatus.setText("获取失败：" + errorMsg);
                    tvConnectionStatus.setTextColor(getResources().getColor(R.color.error_color));
                    tvTemp.setText("--°C");
                    tvHum.setText("--%");
                    break;
            }

        } catch (JSONException e) {
            // 4. 处理JSON解析异常（格式错误等）
            Log.e(TAG, "解析云平台数据失败: " + e.getMessage(), e);
            tvConnectionStatus.setText("数据解析失败（格式错误）");
            tvConnectionStatus.setTextColor(getResources().getColor(R.color.error_color));
            tvTemp.setText("--°C");
            tvHum.setText("--%");
        }
    }

    /**
     * 处理云平台返回的成功数据（解析设备信息并更新UI）
     * @param businessData 业务层JSON对象（code=0时）
     * @throws JSONException JSON解析异常
     */
    private void handleSuccessData(JSONObject businessData) throws JSONException {
        // 从业务层data字段获取设备详细数据
        if (businessData == null) {
            tvConnectionStatus.setText("已连接");
            tvConnectionStatus.setTextColor(getResources().getColor(R.color.success_color));
            tvTemp.setText("--°C");
            tvHum.setText("--%");
            return;
        }

        // 更新温湿度数据（假设温湿度字段在deviceDetail中）
        if (businessData.has("temp")) {
            int temp = businessData.getInt("temp");
            tvTemp.setText(temp + "°C");
        } else {
            tvTemp.setText("--°C");
        }

        if (businessData.has("hum")) {
            int hum = businessData.getInt("hum");
            tvHum.setText(hum + "%");
        } else {
            tvHum.setText("--%");
        }

        // 更新连接状态
        tvConnectionStatus.setText("已连接");
        tvConnectionStatus.setTextColor(getResources().getColor(R.color.success_color));
    }

    /**
     * 注册电池广播接收器
     */
    private void registerBatteryReceiver() {
        batteryReceiver = new BatteryReceiver();
        IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
        registerReceiver(batteryReceiver, filter);
    }

    /**
     * 电池状态广播接收器
     */
    private class BatteryReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (Intent.ACTION_BATTERY_CHANGED.equals(intent.getAction())) {
                updateBatteryLevel();
            }
        }
    }

    /**
     * 更新电池电量显示（获取真实手机电量）
     */
    private void updateBatteryLevel() {
        // 获取电池状态意图
        Intent batteryIntent = getApplicationContext().registerReceiver(
                null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));

        if (batteryIntent != null) {
            // 获取电池电量（0-100）
            int level = batteryIntent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
            int scale = batteryIntent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);

            // 计算电量百分比
            int batteryLevel = -1;
            if (level != -1 && scale != -1) {
                batteryLevel = (int) ((level / (float) scale) * 100);
            }

            // 获取充电状态
            int status = batteryIntent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
            boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
                    status == BatteryManager.BATTERY_STATUS_FULL;

            // 更新UI显示
            if (batteryLevel != -1) {
                String batteryText = batteryLevel + "%";
                // 如果正在充电，添加充电标识
                if (isCharging) {
                    batteryText += " 正在充电";
                }
                tvBattery.setText(batteryText);
            } else {
                tvBattery.setText("未知");
            }
        } else {
            tvBattery.setText("获取失败");
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 停止定时器
        if (dataUpdateTimer != null) {
            dataUpdateTimer.cancel();
            dataUpdateTimer.purge();
        }

        // 移除所有未处理的消息
        if (mainHandler != null) {
            mainHandler.removeCallbacksAndMessages(null);
        }
        if (autoStopHandler != null) {
            autoStopHandler.removeCallbacksAndMessages(null);
        }

        // 注销电池广播接收器
        if (batteryReceiver != null) {
            unregisterReceiver(batteryReceiver);
        }

        // 退出时发送停止指令
        deviceInfo.setCarDirection("stop");
        deviceInfo.setLed("ledOff");
        new Thread(() -> HttpUtils.sendPost(deviceInfo)).start();
    }
}
